package com.gqj.bas.service.impl;

import com.gqj.bas.domain.BasSort;
import com.gqj.bas.mapper.BasSortMapper;
import com.gqj.bas.service.IBasSortService;
import com.gqj.common.constant.UserConstants;
import com.gqj.common.exception.ServiceException;
import com.gqj.common.utils.DateUtils;
import com.gqj.common.utils.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 资产分类Service业务层处理
 *
 * @author lxq
 * @date 2023-12-17
 */
@Service
public class BasSortServiceImpl implements IBasSortService {
    @Autowired
    private BasSortMapper basSortMapper;

    /**
     * 查询资产分类
     *
     * @param sortId 资产分类主键
     * @return 资产分类
     */
    @Override
    public BasSort selectBasSortBySortId(Long sortId) {
        return basSortMapper.selectBasSortBySortId(sortId);
    }

    /**
     * 查询资产分类列表
     *
     * @param basSort 资产分类
     * @return 资产分类
     */
    @Override
    public List<BasSort> selectBasSortList(BasSort basSort) {
        return basSortMapper.selectBasSortList(basSort);
    }

    /**
     * 校验分类名称是否唯一
     *
     * @param basSort 分类信息
     * @return 结果
     */
    @Override
    public String checkSortNameUnique(BasSort basSort) {
        Long sortId = StringUtils.isNull(basSort.getSortId()) ? -1L : basSort.getSortId();
        BasSort info = basSortMapper.checkSortNameUnique(basSort.getSortName(), basSort.getParentId());
        if (StringUtils.isNotNull(info) && info.getSortId().longValue() != sortId.longValue()) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 根据ID查询所有子分类（正常状态）
     *
     * @param sortId 分类ID
     * @return 子分类数
     */
    @Override
    public int selectNormalChildrenSortById(Long sortId) {
        return basSortMapper.selectNormalChildrenSortById(sortId);
    }

    /**
     * 新增资产分类
     *
     * @param basSort 资产分类
     * @return 结果
     */
    @Override
    public int insertBasSort(BasSort basSort) {
        BasSort info = basSortMapper.selectBasSortBySortId(basSort.getParentId());
        if (null != info) {
            // 如果父节点不为正常状态,则不允许新增子节点
            if (!UserConstants.DEPT_NORMAL.equals(info.getDelFlag())) {
                throw new ServiceException("分类已被删除，不允许新增");
            }
            basSort.setAncestors(info.getAncestors() + "," + basSort.getParentId());
        } else {
            basSort.setAncestors(basSort.getParentId().toString());
        }
        basSort.setCreateTime(DateUtils.getNowDate());
        return basSortMapper.insertBasSort(basSort);
    }

    /**
     * 修改资产分类
     *
     * @param basSort 资产分类
     * @return 结果
     */
    @Override
    public int updateBasSort(BasSort basSort) {
        BasSort newParentSort = basSortMapper.selectBasSortBySortId(basSort.getParentId());
        BasSort oldSort = basSortMapper.selectBasSortBySortId(basSort.getSortId());
        if (StringUtils.isNotNull(newParentSort) && StringUtils.isNotNull(oldSort)) {
            String newAncestors = newParentSort.getAncestors() + "," + newParentSort.getSortId();
            String oldAncestors = oldSort.getAncestors();
            basSort.setAncestors(newAncestors);
            updateSortChildren(basSort.getSortId(), newAncestors, oldAncestors);
        } else if(StringUtils.isNull(newParentSort)){
            basSort.setAncestors(basSort.getParentId().toString());
            String oldAncestors = oldSort.getAncestors();
            updateSortChildren(basSort.getSortId(), basSort.getParentId().toString(), oldAncestors);
        }
        basSort.setUpdateTime(DateUtils.getNowDate());
        int result = basSortMapper.updateBasSort(basSort);
        return result;
    }

    /**
     * 修改子元素关系
     *
     * @param sortId       被修改的分类ID
     * @param newAncestors 新的父ID集合
     * @param oldAncestors 旧的父ID集合
     */
    public void updateSortChildren(Long sortId, String newAncestors, String oldAncestors) {
        List<BasSort> children = basSortMapper.selectChildrenSortById(sortId);
        for (BasSort child : children) {
            child.setAncestors(child.getAncestors().replaceFirst(oldAncestors, newAncestors));
        }
        if (children.size() > 0) {
            basSortMapper.updateSortChildren(children);
        }
    }

    /**
     * 是否存在子节点
     *
     * @param sortId 分类ID
     * @return 结果
     */
    @Override
    public boolean hasChildBySortId(Long sortId)
    {
        int result = basSortMapper.hasChildBySortId(sortId);
        return result > 0;
    }

    /**
     * 查询分类是否被引用
     *
     * @param sortId 分类ID
     * @return 结果 true 存在 false 不存在
     */
    @Override
    public boolean checkMaterialExistSort(Long sortId)
    {
        int result = basSortMapper.checkMaterialExistSort(sortId);
        return result > 0;
    }

    /**
     * 批量删除资产分类
     *
     * @param sortIds 需要删除的资产分类主键
     * @return 结果
     */
    @Override
    public int deleteBasSortBySortIds(Long[] sortIds) {
        return basSortMapper.deleteBasSortBySortIds(sortIds);
    }

    /**
     * 删除资产分类信息
     *
     * @param sortId 资产分类主键
     * @return 结果
     */
    @Override
    public int deleteBasSortBySortId(Long sortId) {
        return basSortMapper.deleteBasSortBySortId(sortId);
    }
}
